<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>36.getDerivedStateFromProps</title>
</head>

<body>
    <!-- 准备好一个容器 -->
    <div id="app"></div>
    <!-- 引入react核心库 -->
    <script type="text/javascript" src="../js2/react.development.js"></script>
    <!-- 引入react-dom 用于支持 react 操作 dom -->
    <script type="text/javascript" src="../js2/react-dom.development.js"></script>
    <!-- 引入 label，用于将 jsx 转化为 js -->
    <script type="text/javascript" src="../js/babel.min.js"></script>
    <!-- 引入 prop-types，用于对于组件标签属性进行限制 -->
    <script type="text/javascript" src="../js/prop-types.js"></script>


    <!-- 
        1. 初始化阶段：是由 ReactDOM.render() 触发 -- 初次渲染
            - construtor()
            - getDerivedStateFromProps()
            - render()
            - componentDidMount()
        2. 更新阶段：是由组件内部 this.setState() 或者父组件重新 render 触发
            - getDerivedStateFromProps()
            - shouldComponentUpdate()
            - render()
            - getSnapshotBeforeUpdate()
            - componentDidUpdate()
        3. 卸载组件：由 ReactDOM.unmountComponentAtNode() 触发
            - componentWillUnmount()

     -->


    <!-- 此处必须写 text/babel -->
    <script type="text/babel">

        // 创建组件
        class Count extends React.Component {

            // 构造器
            constructor(props) {
                console.log('Count-constructor')
                super(props)
                // 初始化状态
                this.state = { count: 0 }
            }

            // 加 1 按钮回调
            add = () => {
                const { count } = this.state
                this.setState({ count: count + 1 })
            }

            // 卸载组件
            death = () => {
                ReactDOM.unmountComponentAtNode(document.getElementById('app'))
            }

            // 强制更新回调
            force = () => {
                this.forceUpdate()
            }

            // 得到一个派生的状态从props中，使用状态极低，了解即可，返回状态不可修改
            // 若 state的值在任何时候都取决于props的话，那么可以使用
            static getDerivedStateFromProps(props, state) {
                console.log('Count-getDerivedStateFromProps', props, state)
                return null
                // return props
            }

            // 在更新之前获取快照
            getSnapshotBeforeUpdate() {
                console.log('Count-getSnapshotBeforeUpdate')
                return '我是ed.同学'
            }


            // 组件将要挂载的钩子
            // UNSAFE_componentWillMount() {
            //     console.log('Count-componentWillMount')
            // }

            // 组件挂载完成的钩子
            componentDidMount() {
                console.log("Count-componentDidMount")
            }

            // 组件将要卸载
            componentWillUnmount() {
                console.log("Count-componentWillUnmount")
            }

            // 组件是否应该被更新 （控制组件更新的阀门）
            shouldComponentUpdate() {
                console.log("Count-shouldComponentUpdate")
                return true  // 必须写返回值，如true则更新， false为不更新，不写这个钩子，默认为true
            }

            // // 组件将要被更新
            // UNSAFE_componentWillUpdate() {
            //     console.log("Count-componentWillUpdate")
            // }

            // 组件更新完成
            componentDidUpdate(preProps, preState, SnapshotValue) {
                console.log("Count-componentDidUpdate", preProps, preState, SnapshotValue)
            }


            // 初始化渲染，页面更新时候调用
            render() {
                console.log('Count-render')
                const { count } = this.state
                return (
                    <div>
                        <h2>当前求和结果：{count}</h2>
                        <button onClick={this.add}>点击 + 1</button>
                        <button onClick={this.death}>卸载组件</button>
                        <button onClick={this.force}>不更改任何数据，强制更新</button>
                    </div>
                )
            }
        }

        // 父组件 A
        class A extends React.Component {

            state = { car: '红旗' }

            changeCar = () => {
                this.setState({ car: '比亚迪' })
            }

            render() {
                return (
                    <div>
                        <div>A 组件</div>
                        <button onClick={this.changeCar}>换车</button>
                        <B car={this.state.car} />
                    </div>
                )
            }
        }

        // 子组件 B
        class B extends React.Component {

            // 组件将要接收到新的传进的参数钩子
            // UNSAFE_componentWillReceiveProps(props) {
            //     // 第一次传进来的不算
            //     console.log('B---componentWillReceiveProps', props)
            // }

            render() {
                console.log("B---render")
                return (
                    <div>B 组件，接受到的车是：{this.props.car}</div>
                )
            }
        }

        // 渲染组件
        ReactDOM.render(<Count name="我是ed." />, document.getElementById("app"))
    </script>

</body>

</html>